import axios from 'axios'

// 创建axios实例
const api = axios.create({
  baseURL: process.env.NODE_ENV === 'production' ? '/api' : '',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 在发送请求之前做些什么
    console.log('发送请求:', config.url)
    return config
  },
  error => {
    // 对请求错误做些什么
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 对响应数据做点什么
    return response.data
  },
  error => {
    // 对响应错误做点什么
    console.error('响应错误:', error)
    return Promise.reject(error)
  }
)

/**
 * 数据API服务类
 * 统一管理所有数据请求
 */
class DataApiService {
  /**
   * 获取堆场列表数据
   * @returns {Promise<axios.AxiosResponse<any>>} 堆场列表
   */
  async getYardList() {
    try {
        return await api.get('/data/yard-data.json')
    } catch (error) {
      console.error('获取堆场列表失败:', error)
      throw error
    }
  }

  /**
   * 获取集装箱数据
   * @param {string} yardId - 堆场ID，可选
   * @returns {Promise<axios.AxiosResponse<any>>} 集装箱数据列表
   */
  async getContainerData(yardId = null) {
    try {
      // 如果指定了堆场ID，优先尝试获取特定堆场的数据
      if (yardId) {
        try {
            return await api.get(`/data/container-data-${yardId.toLowerCase()}.json`)
        } catch (error) {
          // 如果特定堆场数据不存在，继续尝试通用数据
          console.log(`特定堆场 ${yardId} 数据不存在，尝试通用数据`)
        }
      }

      // 获取通用集装箱数据
      const response = await api.get('/data/container-data.json')
      
      // 如果指定了堆场ID，过滤出该堆场的数据
      if (yardId) {
        return response.filter(container => container.block === yardId)
      }
      
      return response
    } catch (error) {
      console.error('获取集装箱数据失败:', error)
      return []
    }
  }

  /**
   * 获取堆场计划数据
   * @param {string} yardId - 堆场ID，可选
   * @returns {Promise<axios.AxiosResponse<any>>} 计划数据列表
   */
  async getYardPlans(yardId = null) {
    try {
      // 如果指定了堆场ID，优先尝试获取特定堆场的计划
      if (yardId) {
        try {
            return await api.get(`/data/yard-plans-${yardId.toLowerCase()}.json`)
        } catch (error) {
          // 如果特定堆场计划不存在，继续尝试通用计划
          console.log(`特定堆场 ${yardId} 计划不存在，尝试通用计划`)
        }
      }

      // 获取通用计划数据
      const response = await api.get('/data/yard-plans.json')
      
      // 如果指定了堆场ID，过滤出该堆场的计划
      if (yardId) {
        return response.filter(plan => plan.yardId === yardId)
      }
      
      return response
    } catch (error) {
      console.error('获取堆场计划失败:', error)
      return []
    }
  }

  /**
   * 获取堆场加锁数据
   * @param {string} yardId - 堆场ID，可选
   * @returns {Promise<axios.AxiosResponse<any>>} 加锁数据列表
   */
  async getYardLocks(yardId = null) {
    try {
      // 如果指定了堆场ID，优先尝试获取特定堆场的加锁
      if (yardId) {
        try {
            return await api.get(`/data/yard-locks-${yardId.toLowerCase()}.json`)
        } catch (error) {
          // 如果特定堆场加锁不存在，继续尝试通用加锁
          console.log(`特定堆场 ${yardId} 加锁不存在，尝试通用加锁`)
        }
      }

      // 获取通用加锁数据
      const response = await api.get('/data/yard-locks.json')
      
      // 如果指定了堆场ID，过滤出该堆场的加锁
      if (yardId) {
        return response.filter(lock => lock.yardId === yardId)
      }
      
      return response
    } catch (error) {
      console.error('获取堆场加锁失败:', error)
      return []
    }
  }

  /**
   * 保存堆场计划
   * @param {Object} planData - 计划数据
   * @returns {Promise<Object>} 保存结果
   */
  async saveYardPlan(planData) {
    try {
      // 获取现有计划数据
      const existingPlans = await this.getYardPlans()
      
      // 创建新计划对象
      const newPlan = {
        planId: `plan_${Date.now()}`,
        yardId: planData.yardId,
        startBay: planData.startBay,
        endBay: planData.endBay,
        startRow: planData.startRow,
        endRow: planData.endRow,
        description: planData.description || '',
        createdAt: new Date().toISOString(),
        color: planData.color || '#007bff'
      }
      
      // 添加到现有计划中
      const updatedPlans = [...existingPlans, newPlan]
      
      // 这里应该调用后端API保存，目前只是模拟
      console.log('保存计划:', newPlan)
      console.log('更新后的计划列表:', updatedPlans)
      
      return newPlan
    } catch (error) {
      console.error('保存堆场计划失败:', error)
      throw error
    }
  }

  /**
   * 保存堆场加锁
   * @param {Object} lockData - 加锁数据
   * @returns {Promise<Object>} 保存结果
   */
  async saveYardLock(lockData) {
    try {
      // 获取现有加锁数据
      const existingLocks = await this.getYardLocks()
      
      // 创建新加锁对象
      const newLock = {
        lockId: `lock_${Date.now()}`,
        yardId: lockData.yardId,
        bay: lockData.bay,
        row: lockData.row,
        description: lockData.description || '',
        lockTime: new Date().toISOString(),
        lockOperator: lockData.lockOperator || '系统',
        lockReason: lockData.lockReason || '手动加锁',
        color: lockData.color || '#FF9800'
      }
      
      // 添加到现有加锁中
      const updatedLocks = [...existingLocks, newLock]
      
      // 这里应该调用后端API保存，目前只是模拟
      console.log('保存加锁:', newLock)
      console.log('更新后的加锁列表:', updatedLocks)
      
      return newLock
    } catch (error) {
      console.error('保存堆场加锁失败:', error)
      throw error
    }
  }

  /**
   * 更新堆场计划
   * @param {string} planId - 计划ID
   * @param {Object} planData - 计划数据
   * @returns {Promise<Object>} 更新结果
   */
  async updateYardPlan(planId, planData) {
    try {
      // 获取现有计划数据
      const existingPlans = await this.getYardPlans()
      
      // 找到要更新的计划
      const planIndex = existingPlans.findIndex(plan => plan.planId === planId)
      if (planIndex === -1) {
        throw new Error(`计划 ${planId} 不存在`)
      }
      
      // 更新计划数据
      const updatedPlan = {
        ...existingPlans[planIndex],
        startBay: planData.startBay,
        endBay: planData.endBay,
        startRow: planData.startRow,
        endRow: planData.endRow,
        description: planData.description || existingPlans[planIndex].description,
        updatedAt: new Date().toISOString()
      }
      
      // 更新计划列表
      const updatedPlans = [...existingPlans]
      updatedPlans[planIndex] = updatedPlan
      
      // 这里应该调用后端API更新，目前只是模拟
      console.log('更新计划:', updatedPlan)
      console.log('更新后的计划列表:', updatedPlans)
      
      return {
        updatedPlan: updatedPlan,
        updatedPlans: updatedPlans,
        success: true
      }
    } catch (error) {
      console.error('更新堆场计划失败:', error)
      throw error
    }
  }

  /**
   * 更新堆场位置
   * @param {string} yardId - 堆场ID
   * @param {Object} position - 位置信息 {x, y, rotation}
   * @returns {Promise<Object>} 更新结果
   */
  async updateYardPosition(yardId, position) {
    try {
      // 这里应该调用后端API更新位置
      console.log('更新堆场位置:', yardId, position)
      
      // 模拟保存到服务器（实际项目中应该调用真实API）
      // await api.put(`/yards/${yardId}/position`, position)
      
      // 暂时保存到本地存储作为备份
      const savedPositions = JSON.parse(localStorage.getItem('yardPositions') || '[]')
      const existingIndex = savedPositions.findIndex(pos => pos.yardId === yardId)
      
      const positionData = {
        yardId: yardId,
        x: position.x,
        y: position.y,
        rotation: position.rotation || 0,
        updatedAt: new Date().toISOString()
      }
      
      if (existingIndex >= 0) {
        savedPositions[existingIndex] = positionData
      } else {
        savedPositions.push(positionData)
      }
      
      localStorage.setItem('yardPositions', JSON.stringify(savedPositions))
      console.log('堆场位置已保存到本地存储:', positionData)
      
      return { 
        success: true, 
        yardId, 
        position: positionData,
        message: '堆场位置已保存'
      }
    } catch (error) {
      console.error('更新堆场位置失败:', error)
      throw error
    }
  }

  /**
   * 删除堆场计划
   * @param {string} planId - 计划ID
   * @returns {Promise<boolean>} 删除结果
   */
  async deleteYardPlan(planId) {
    try {
      // 这里应该调用后端API删除计划
      console.log('删除计划:', planId)
      
      return true
    } catch (error) {
      console.error('删除堆场计划失败:', error)
      throw error
    }
  }

  /**
   * 删除堆场加锁
   * @param {string} lockId - 加锁ID
   * @returns {Promise<boolean>} 删除结果
   */
  async deleteYardLock(lockId) {
    try {
      // 这里应该调用后端API删除加锁
      console.log('删除加锁:', lockId)
      
      return true
    } catch (error) {
      console.error('删除堆场加锁失败:', error)
      throw error
    }
  }
}

// 创建API服务实例
const dataApiService = new DataApiService()

// 导出API服务实例和axios实例
export default dataApiService
export { api }
